Що таке оператор “->” в C ++?

-> не є оператором. Це фактично два окремі оператори, - і>.
Код умовного оператора зменшує x, одночасно повертаючи початкове (не зменшене) значення x, а потім порівнює вихідне значення з 0 за допомогою оператора>.
Для кращого розуміння висловлювання можна написати так:
в той час як ((x--)> 0)
|
Або для чогось зовсім іншого ... х слайдів до 0.
в той час як (х - \
\
\
\
> 0)
printf ("% d", x);
Не так математично, але ... кожна картинка малює тисячу слів ...
|
Це дуже складний оператор, тому навіть ISO / IEC JTC1 (Спільний технічний комітет 1) розмістив його опис у двох різних частинах стандарту C ++.
Жартуючи, це два різні оператори: - і>, описані відповідно в §5.2.6 / 2 та §5.9 Стандарту C ++ 03.
|
Це еквівалентно
в той час як (x--> 0)
x-- (після зменшення) еквівалентно x = x-1, отже, код перетворюється на:
в той час як (x> 0) {
х = х-1;
// логіка
}
x--; // Зменшення розміру, виконане, коли x <= 0
|
x може йти до нуля ще швидше у зворотному напрямку:
int x = 10;
при цьому (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Ви можете контролювати швидкість за допомогою стрілки!
int x = 100;
в той час як (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Його
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x переходить до 0
printf ("% d", x);
}
повернути 0;
}
Просто простір робить речі виглядають кумедно, - зменшує і> порівнює.
|
Використання -> має історичну актуальність. Зменшення було (і в деяких випадках це відбувається) швидше, ніж збільшення на архітектурі x86. Використання -> припускає, що x має значення 0, і звертається до тих, хто має математичний досвід.
|
в той час як (x--> 0)
це те, як це аналізується.
|
Зовсім нелюди, але я буду використовувати це:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
виконайте printf ("n дорівнює% d \ n", n) як (n -> 0);
повернути 0;
}
|
В одній книзі, яку я прочитав (я не пам’ятаю, яку саме книгу), було сказано: компілятори намагаються проаналізувати вирази за найбільшим маркером, використовуючи ліве праворуч правило.
У цьому випадку вираз:
x -> 0
Аналізується за найбільшими токенами:
маркер 1: x
маркер 2: -
маркер 3:>
маркер 4: 0
зробити висновок: x--> 0
Те саме правило застосовується до цього виразу:
a ----- b
Після розбору:
маркер 1: а
маркер 2: -
маркер 3: -
маркер 4: -
маркер 5: б
зробити висновок: (a -) - - b
Сподіваюся, це допомагає зрозуміти складний вираз ^^
|
Це точно так само, як
в той час як (x--)
{
printf ("% d", x);
}
для невід’ємних чисел
|
У будь-якому випадку, зараз у нас є оператор "переходить до". "->" легко запам'ятати як напрямок, а "поки х іде до нуля" означає пряме значення.
Крім того, це трохи ефективніше, ніж "for (x = 10; x> 0; x -)" на деяких платформах.
|
Цей код спочатку порівнює x та 0, а потім зменшує x. (Також сказано у першій відповіді: Ви зменшуєте x після, а потім порівнюєте x та 0 з оператором>.) Див. Результати цього коду:
9 8 7 6 5 4 3 2 1 0
Тепер ми спочатку порівнюємо, а потім зменшуємо, бачачи 0 на виході.
Якщо ми хочемо спочатку зменшити, а потім порівняти, використовуйте цей код:
#include 
int main (void)
{
int x = 10;
while (--x> 0) // x переходить до 0
{
printf ("% d", x);
}
повернути 0;
}
Цей результат:
9 8 7 6 5 4 3 2 1
|
Мій компілятор роздрукує 9876543210 під час запуску цього коду.
#include 
int main ()
{
int x = 10;
while (x -> 0) // x переходить до 0
{
std :: cout << x;
}
}
Як і очікувалося. While (x--> 0) насправді означає while (x> 0). Значення x - після зменшення x.
в той час як (x> 0)
{
x--;
std :: cout << x;
}
це інший спосіб писати одне і те ж.
Приємно, що оригінал виглядає як "в той час як x переходить до 0".
|
Між - і> відсутній пробіл. x поступово зменшується, тобто зменшується після перевірки умови x> 0?
|
- оператор зменшення та> - оператор більший за.
Два оператори застосовуються як єдиний, наприклад ->.
|
Це поєднання двох операторів. Перший - призначений для зменшення значення, а> - для перевірки того, чи більше значення, ніж правий операнд.
#include 
int main ()
{
int x = 10;
в той час як (x--> 0)
printf ("% d", x);
повернути 0;
}
Результатом буде:
9 8 7 6 5 4 3 2 1 0
|
Насправді, x виконує постдекрементування і з цим умовою перевіряється. Це не ->, це (x--)> 0
Примітка: значення x змінюється після перевірки умови, оскільки воно відбувається після зменшення. Також можуть траплятися деякі подібні випадки, наприклад:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C і C ++ підкоряються правилу "максимального обжерливого". Так само, як a --- b перекладається на (a--) - b, у вашому випадку x -> 0 перекладається на (x -)> 0.
Правило, по суті, говорить про те, що, рухаючись зліва направо, вирази формуються, беручи максимум символів, які утворюють дійсний вираз.
|
Чому все ускладнення?
Проста відповідь на вихідне запитання:
#include 
int main ()
{
int x = 10;
в той час як (x>0)
{
printf ("% d", x);
х = х-1;
}
}
Це робить те саме. Я не кажу, що ви повинні робити це так, але це робить те саме, і відповів би на запитання в одному дописі.
Значення x-- це просто скорочення для вищезазначеного, а> - це звичайний оператор, більший ніж. Ніякої великої таємниці!
Сьогодні дуже багато людей, які ускладнюють прості речі;)
|
Звичайним способом ми визначаємо умову в дужці циклу while () та завершальну умову всередині фігурних дужок {}, але -> визначає обидва відразу.
Наприклад:
int abc (void)
{
int a = 5
while ((a--)> 0) // Зменшення та порівняння одночасно
{
// Код
}
}
Це зменшує a і запускає цикл, тоді як a більше 0.
Звичайно це було б так:
int abc (void)
{
int a = 5;
в той час як (a> 0)
{
a--;
// Код
}
a--;
}
В обох напрямках ми робимо одне і те ж і досягаємо однакових цілей.
|
(x -> 0) означає (x--> 0).
Ви можете використовувати (x ->) Вихід: 9 8 7 6 5 4 3 2 1 0
Ви можете використовувати (- x> 0) Це означає (--x> 0) Вихід: 9 8 7 6 5 4 3 2 1
Можна використовувати
(- \
\
x> 0)
Вихід: 9 8 7 6 5 4 3 2 1
Можна використовувати
(\
\
x -> 0)
Вихід: 9 8 7 6 5 4 3 2 1 0
Можна використовувати
(\
\
x -> 0
\
\
)
Вихід: 9 8 7 6 5 4 3 2 1 0
Ви також можете використовувати
(
х
->
)
Вихід: 9 8 7 6 5 4 3 2 1 0
Так само ви можете спробувати безліч методів для успішного виконання цієї команди.
|
Тут - це одинарний оператор декрементування.
while (x--> 0) // x переходить до 0
{
printf ("% d", x);
}
На початку стан оцінюватиметься як
(x> 0) // 10> 0
Тепер, оскільки умова є істинною, вона перейде в цикл із зменшеним значенням
x-- // x = 9
Ось чому перше друковане значення - 9
І так далі. В останньому циклі x = 1, отже умова відповідає дійсності. Згідно з одинарним оператором, на момент друку значення змінилося на x = 0.
Тепер x = 0, яке обчислює умову (x> 0) як хибну, а цикл while виходить.
|
Це -> взагалі не є оператором. У нас є оператор типу ->, але не як ->. Це просто неправильна інтерпретація while (x--> 0), що просто означає, що x має оператор після зменшення, і цей цикл буде працювати, поки він не перевищить нуль.
Ще одним простим способом написання цього коду буде while (x--). Цикл while зупиняється, коли отримує помилкову умову, і тут є лише один випадок, тобто 0. Таким чином, він зупиняється, коли значення x зменшується до нуля.
|
Високоактивне запитання. Заробіть 10 репутації, щоб відповісти на це питання. Вимога про репутацію допомагає захистити це питання від спаму та відсутності відповідей.
Не відповідь, яку ви шукаєте? Перегляньте інші запитання, позначені тегами операторів c ++ c, які відповідають стандартам форматування коду, або задайте власне запитання.